Providing application operational insights to users based on crowd sourced performance metrics for operational states

ABSTRACT

A method includes performing operations on a processor of an application analysis computer. The operations include receiving reports from user terminals containing identifiers for operational states of an application being processed by the user terminals and containing state performance metrics. Each of the state performance metrics indicates a measurement of performance for a corresponding identified one of the operational states of the application being processed by one of the user terminals. The operations further include, for each of the operational states of the application identified in the reports, generating a rule for acceptable performance of the operational state of the application based on the state performance metrics of the operational state reported by the user terminals. The operations further include storing in a repository the rules associated with identifiers for corresponding ones of the operational states of the application. Related operations by a user terminal are disclosed.

BACKGROUND

The present disclosure relates to computing systems, and, in particular,to management of application programs processed by user terminals.

Users can install a myriad of different types of application programs(also commonly referred to as “applications” and “apps”) on userterminals having widely varying software and hardware characteristics.For example, users can select from among several million differentapplications available on various application servers for downloading tocellular telephones (sometimes called “smart phones”), tablet computers,laptop computers, and other types of user terminals for processing. Overa billion Apple IOS user terminals and Android user terminals arepresently being used throughout the world.

Application operational behavior can be highly unpredictable from a userperspective. An application may appear to be operating incorrectly,responding sluggishly, and/or crashed (e.g., not responding to userinput). There are many reasons application operation can becomeunpredictable. A user may provide erroneous input to the application ormay not be able to effectively operate the application. Applicationoperation requires access to resources located on the user terminal andwhich can also be remotely located in network servers or other networkeddevices. Other applications executing on the mobile terminal andcommunication problems can delay or prevent application access to suchresources. Moreover, users are able to limit resource permissions of anapplication, which can further interfere with application operation.Such operational unpredictability detracts from the user's experienceand can result in low application usage and poor recommendations toothers.

SUMMARY

Some embodiments of the present disclosure are directed to a method ofperforming operations on a processor of an application analysiscomputer. The operations include receiving reports from user terminalscontaining identifiers for operational states of an application beingprocessed by the user terminals and containing state performancemetrics. Each of the state performance metrics indicates a measurementof performance for a corresponding identified one of the operationalstates of the application being processed by one of the user terminals.The operations further include, for each of the operational states ofthe application identified in the reports, generating a rule foracceptable performance of the operational state of the application basedon the state performance metrics of the operational state reported bythe user terminals. The operations further include storing in arepository the rules associated with identifiers for corresponding onesof the operational states of the application.

Some other embodiments of the present disclosure are directed to amethod of performing operations on a processor of an user terminal. Theoperations include generating state performance metrics, andcommunicating the state performance metrics to an application analysiscomputer via a data network. Each of the state performance metricsindicates a measurement of performance of one of a plurality ofoperational states of an application processed by the user terminal. Theoperations further include determining an action responsive to one ofthe state performance metrics for one of the operational states beingdetermined to violate a rule for acceptable operational stateperformance of the application, and controlling operation of theapplication during the one of the operational states responsive to theaction.

Other methods, application analysis computers, and/or user terminalsaccording to embodiments of the present disclosure will be or becomeapparent to one with skill in the art upon review of the followingdrawings and detailed description. It is intended that all suchadditional methods, application analysis computers, and/or userterminals be included within this description, be within the scope ofthe present inventive subject matter, and be protected by theaccompanying claims. Moreover, it is intended that all embodimentsdisclosed herein can be implemented separately or combined in any wayand/or combination.

BRIEF DESCRIPTION OF THE DRAWINGS

Other features of embodiments will be more readily understood from thefollowing detailed description of specific embodiments thereof when readin conjunction with the accompanying drawings, in which:

FIG. 1 is a block diagram of a system for generating rules foracceptable state performance metrics from an application based oncrowd-sourced metrics and providing contextual insights and/orcontrolling operation based on the rules, in accordance with someembodiments of the present disclosure;

FIG. 2 is a combined data flow diagram and flowchart of operations by auser terminal and an application analysis computer for generating rulesfor acceptable state performance metrics from an application andproviding contextual insights and/or controlling operation based on therules, in accordance with some embodiments of the present disclosure;

FIG. 3 is a combined data flow diagram and flowchart of operations by auser terminal for generating rules for acceptable state performancemetrics from an application and providing contextual insights and/orcontrolling operation based on the rules, in accordance with someembodiments of the present disclosure;

FIGS. 4 and 5 illustrated example contextual cues that can be displayedon a display device of a user terminal and associated operations inaccordance with some embodiments of the present disclosure;

FIG. 6 is a flowchart of operations that can be performed by a userterminal and/or by an application analysis computer responsive to stateperformance metrics in accordance with some embodiments of the presentdisclosure;

FIG. 7 is a block diagram of a user terminal configured according tosome embodiments of the present disclosure; and

FIG. 8 is a block diagram of an application analysis computer configuredaccording to some embodiments of the present disclosure.

DETAILED DESCRIPTION

In the following detailed description, numerous specific details are setforth in order to provide a thorough understanding of embodiments of thepresent disclosure. However, it will be understood by those skilled inthe art that the present invention may be practiced without thesespecific details. In other instances, well-known methods, procedures,components and circuits have not been described in detail so as not toobscure the present invention. It is intended that all embodimentsdisclosed herein can be implemented separately or combined in any wayand/or combination.

As explained above, applications executed by user terminals can havehighly unpredictable operational behavior. Because the unpredictablebehavior is oftentimes due to internal resource conflicts within theuser terminal, users have no visibility into why an application isperforming sluggishly, not responding, and/or appearing to otherwiseoperate improperly. Some applications may be configured to respond to atransaction taking too long by, irrespective of the underlying cause,displaying a graphical wait symbol or filling in a progress bar, and/ordisplaying generic statements such as “unable to process a requestplease try again,” “booking failed,” “payment unsuccessful,” etc. Usersmay improperly assume that they have entered improper data, improperlyoperated the application, and/or conclude the application isprogrammatically flawed. However, the problem may arise due toinsufficient or lack of network communication bandwidth between the userterminal and a remote network server, insufficient internal memory,insufficient processor bandwidth, and/or blocked or unavailable accessto user terminal resources such as GPS receiver, WiFi transceiver,cellular transceiver, camera, Internet resource, contact informationrepository, etc. These and other incorrect assumptions by the userdetract from the user's experience with application.

Some embodiments of the present disclosure are directed to generatingand providing run time contextual insights to users identifying anunderlining basis for a problem being experienced by an applicationexecuted by a user terminal. Some additional or other embodiments of thepresent disclosure are directed to triggering remedial actions by theuser terminal to attempt to remedy the problem experienced by theapplication.

FIG. 1 is a block diagram of a system for generating rules foracceptable state performance metrics from an application based oncrowd-sourced metrics and providing contextual insights and/orcontrolling operation based on the rules, in accordance with someembodiments of the present disclosure. The system includes userterminals 100 a-100 n, radio access networks (RAN) 160, and anapplication analysis computer 150 configured according to someembodiments of the present disclosure. The user terminals 100 a-100 ncan download application programs from an application server. Theapplication server may, for example, include the Apple application storeserver (e.g., iTunes) and/or one or more of the Android applicationstore server (e.g., Google Play and/or Amazon Appstore). The applicationprograms can include gaming programs, spreadsheet programs, multimediaprograms, word processing programs, database programs, presentationprograms, etc.

The user terminals 100 a-100 n may communicate through a wireless and/orwired network connection via a data network 162 with the applicationanalysis computer 150 and the application server. For example, one ormore of the user terminals 100 a-100 n may communicate through the radioaccess networks 160 using one or more wireless communication protocolsthat may include, but are not limited to, LTE, WLAN (IEEE 802.11),WiMax, and/or Bluetooth.

Although FIG. 1 illustrates a certain number of system components forease of illustration and explanation, it is to be understood thatembodiments of the present disclosure are not limited to the illustratedconfiguration but instead are intended to encompass any configurationcapable of carrying out at least some of the operations describedherein.

The application 104 can include a performance monitoring plug-in 105that generates state performance metrics. The plug-in 105 can generateeach of the state performance metrics to indicate a measurement,performed by the plug-in 105, of performance of one of a plurality ofoperational states of the application 104 while being processed by theuser terminal 100.

Example operational states of the application 104 can include any one ormore of a first operational state during which the application 104requests a present location from a GPS resource of the user terminal100, a second operational state during which the application 104requests to access a network node through a WiFi resource of the userterminal 100, a third operational state during which the application 104requests to access a network node through a cellular resource of theuser terminal 100, a fourth operational state during which theapplication 104 requests to access picture data and/or video data streamfrom the camera resource of the user terminal 100, a fifth operationalstate during which the application 104 requests to access contactinformation data structure residing in a contact information repositoryresource of the user terminal 100, etc.

The plug-in 105 communicates the state performance metrics to theapplication analysis computer 150 via the data network 162 and radioaccess network(s) 160. The state performance metrics can be communicatedto the application analysis computer 150 in reports that includeidentifiers for the operational states of the application 104 beingprocessed by the user terminal 100. In one embodiment, each reportcontains an identifier for an operational state of the application 104and a corresponding state performance metric that has been generated bymonitoring performance of the application 104 while being processed inthat operational state. In another embodiment, each report can contain aplurality of pairs of one of the operational state identifiers and oneof the state performance metrics.

The application analysis computer 150 can include an analysis component110 configured to receive the reports from the user terminals 100 a-100n. The reports can contain identifiers for operational states of theapplication 104 being processed by the user terminals 100 a-100 n andcontain state performance metrics for the identified operational states.The application analysis computer 150 can use the identifier containedin one of the reports for one of the operational states of theapplication 104 to retrieve a corresponding rule from the repository120, and use the rule to determine whether it is violated by the stateperformance metric contained in the report. The user terminals 100 a-100n may have different hardware and software platforms, so that the stateperformance metrics represent cross-platform measurements of theperformance of various application operational states. For example, thedifferent user terminal hardware configurations can include differentrandom access memory capacities, different memory space allocations foruse by the application, different network communication technologiesavailable for use by the application (e.g., Bluetooth, WiFi, cellular3G, cellular 4G LTE, etc.), different permission settings for resourcesare available for use by the application (e.g., contact informationrepository, GPS location, Wi-Fi transceiver, cellular transceiver,Bluetooth transceiver, front-facing camera, back-facing camera, speaker,microphone, etc.). different user terminal software configurations caninclude different operating system types and/or versions, differentresident applications and/or versions, different sets of presentlyexecuting applications, etc. of the user terminals 100 a-100 n.

In this manner, the application analysis computer 150 can receivereports indicating the measured performance of various definedoperational states of the application 104 being processed by numerousdifferent user terminals 100 a-100 n which may have differing hardwareand/or software platform characteristics.

A rules generator 130 generates, for each of the operational states ofthe application 104 identified in the reports (e.g., first operationalstate, second operational state, . . . or nth operational state), a rulefor acceptable performance of the operational state of the application104 based on the state performance metrics of the operational statereported by the user terminals 100 a-100 n. The rules are stored in arules repository 120 to indicate an acceptable performance of each ofthe identified operational states of the application 104.

The rules are referred to as crowd sourced because each rule isgenerated based on state performance metric received from a plurality ofuser terminals 100 a-100 n. In some embodiments, the rules may begenerated based on state performance metric reported by, for example,thousands or hundreds of thousands of different user terminals. The userterminals 100 a-100 n can have different users and be operated dispersedacross a large geographic region, and can further have differenthardware platforms and/or software platforms as explained herein. Thestate performance metrics can therefore be generated while the varioususer terminals 100 a-100 n have different user terminal hardware andsoftware resources available for use by the application 104, and whilethe user terminals 100 a-100 n can be using vastly different types andcapabilities of communication network to communicate with networkresources.

The rules can be generated by the rules generator 130 based onmathematical combinations of the state performance metrics reported bythe user terminals 100 a-100 n. For example, a rule for an acceptablestate performance metric for a particular one of the operational statesof the application 104 may be generated by mathematically combining thestate performance metrics for the operational state to generate athreshold value representing a boundary limit for acceptable performanceof the operational state. The mathematical combining may includegenerating a statistical representation of a boundary identified fromthe reported state performance metrics for what a reasonable responsetime is to an API call from the application 104 to a particular type ofresource of the user terminal 100. The threshold value can be definedbased on the boundary.

In one embodiment, the threshold value represents a maximum wait timethe application 104 is to wait to receive a response to an applicationprogramming interface (API) call by the application 104 in one of theoperational states. In another embodiment, the threshold valuerepresents a maximum latency allowed for a response to be provided tothe API call by the application 104 in one of the operational states. Insome other embodiments, a first rule identifies a minimum display updaterate that needs to be performed by the application 104 during a firstone of the operational states without violating the first rule, a secondrule identifies a minimum processor bandwidth available for use by theapplication 104 while operating in a second one of the operationalstates without violating the second rule, a third rule identifies aminimum memory space available for use by the application 104 whileoperating in a third one of the operational states without violating thethird rule, and a fourth rule identifies a minimum network bandwidthavailable for use by the application 104 while operating in a fourth oneof the operational states without violating the fourth rule.

With continued reference to FIG. 1, the monitoring plug-in 105 generatesand reports performance state metrics during execution of the variousoperational states of the application 104 by the user terminal 100. Themonitoring plug-in 105 may be provided by a software development kit(SDK) and inserted within the application 104. The plug-in 105 may beseparate from the application 104 and called by programmatic hooks thatare inserted into various ones of the operational states of theapplication while for that are to be measured to generate correspondingstate performance metrics.

The monitoring plug-in 105 may intercept or otherwise observe API callsfrom the application 104 to other applications processed by the userterminal 100, an operating system processed by the user terminal 100,and/or other software/hardware resources of the user terminal 100. Asused herein, an “API call” can be any signaling occurring from one toanother software application that may be performed using a definedsyntax and one or more parameters (e.g., data structure, object classes,and/or variables) to obtain data therefrom and/or to provide datathereto. For example, SOAP and REST service requests can be performedusing a defined API library of remote calls or other types of APIrequests.

The plug-in 105 measures operation of individual ones of a plurality ofdefined operational states of the application 104 during execution bythe user terminal 100, based on the observed API calls from theapplication 104 to resources of the user terminal 100 and/or based onsystem events provided by the operating system to the application 104.The plug-in 105 generates state performance metrics based on themeasurements. Each of the state performance metrics indicates ameasurement of performance of one of a plurality of operational statesof the application 104. The plug-in 105 communicates the stateperformance metrics to the application analysis computer 150 via theradio access network 160 and the data network 162 (e.g., Internet,private network, etc.).

The types of measurements of an operational state of the application 104that can be performed by the plug-in 105 to generate a state performancemetric may include, but is not limited to, any one or more of thefollowing:

-   -   1. latency for a response to be provided to an API call by the        application 104;    -   2. an elapsed time waiting without having received a response to        an API call by the application 104;    -   3. application utilization of processor resources of the user        terminal 100;    -   4. application utilization of memory resources of the user        terminal 100;    -   5. rate of information displayed by the application 104 on a        display device of the user terminal 100;    -   6. application utilization of network communication resources of        the user terminal 100; and    -   7. communication latency between the application 104 and another        application and/or a network node through a network interface of        the user terminal 100.

A state performance metric may identify the measurement value (e.g.,latency, elapsed time, and/or resource utilization) and/or may include ascreen shot captured from a user terminal display or sub-windowassociated with the application 104, video captured from the userterminal display or sub-window associated with the application 104, ageographic region of the user terminal 100 while the application 104 isbeing processed, and/or characteristics of the hardware platform (e.g.,processor type, volatile memory space, non-volatile memory space,network interface identification, etc.) and/or software platform (e.g.,operating system type and version, identification of residentapplications and versions, identification of presently executingapplications, etc.) of the user terminal 100.

The application analysis computer 150 can includes an applicationoperation controller 114 that determines when one of the stateperformance metrics reported by one of the user terminals 100 a-100 nviolates one of the rules in the repository 120 for acceptableoperational state performance for the corresponding one of theoperational states of the application 104. The application operationcontroller 114 determines when one of the state performance metricsreported by one of the user terminals (e.g., 100 a) violates a rule foracceptable operational state performance of the application 104. Theapplication operation controller 114 communicates a response message tothe one of the user terminals (e.g., 100 a) responsive to thedetermination that the one of the state performance metrics violates therule. As will be explained in further detail below, the applicationoperation controller 114 may include a generator 116 that generatescontextual cues that indicate a root cause of the problem experienced bythe application 104, and/or an operational command generator 118 thatgenerates a command to control operation of the application 104 and/orthe plug-in 105.

The rules generator 130 can modify the rules over time based on analysisof the state performance metrics reported over such time by the userterminals 100 a-100 n from measurements during particular operationalstates of the application 104. Thus, for example, a threshold value foran acceptable response latency observed from run-time tests of earlyreleased version(s) of the application 104 can be subsequently modifiedresponsive to state performance metrics reported over time by the userterminals 100 a-100 n for the response latencies measuring duringoperation of a particular operational state of subsequent releasedversion(s) of the application 104. Continuing measurements of theapplication 104 can thereby be used to adapt what values and/or logicalconditions the rules define to be acceptable boundaries for performanceof identified ones of the application operational states.

FIG. 2 is a combined data flow diagram and flowchart of operations by auser terminal 100 and an application analysis computer 150 forgenerating crowd-sourced based rules for acceptable state performancemetrics from an application and providing contextual insights and/orcontrolling operation based on the rules, in accordance with someembodiments of the present disclosure.

Referring to FIG. 2, the application 104 while processed by the userterminal 100 performs (block 200) API calls and/or receives systemevents. An operating system can notify the application 104 of systemevents associated with the application 104. A system event is an actionof the system that must be handled by the application 104, such as“launch app”, “OnStart”, “OnStop”, etc. For example, the operatingsystem may generate a “launch app” event in response to a user tappingon an app in the user interface of the user terminal 100. System eventsare processed by a responsive function in the application 104. The stateperformance monitoring plug-in 105 may monitor (e.g., intercept) systemevents and determine if an action should be taken in response to thesystem event. For example, the plug-in 105 may record the system event,generate a notification in response to the system event, etc.

The logic of the plug-in 105 may also determine whether or not thesystem event should be passed along to the application 104. Accordingly,the plug-in 105 may implement logic that monitors for system eventsprovided to the application 104. It is noted that the responsivefunction of the application 104 may be left in place to processes systemevents that are passed through to the application 104 by the plug-in105.

For example, the operating system may generate an “onResume” event whichis intercepted by the plug-in 105. If the logic in the plug-in 105determines that the application 104 is not authorized to resume, thenthe plug-in 105 blocks the event by not forwarding it to the responsivefunction in the application 104.

The state performance monitoring plug-in 105 may also monitor (e.g.,intercept) API calls by the application 104 to the operating system orother resources of the user terminal 100. The application 104 issues anAPI call to request services from the operating system or otherresources. For example, an API call may be used to turn on or readcamera/video data from a camera, to read data from storage, to displayan image on a screen, to pass data to another application (e.g., to anencryption application, communication application, etc.), or to invokeany other functionality provided by the operating system.

The state performance monitoring plug-in 105 may pass the API call alongto the operating system or other resource. Before the API call is passedto the operating system, the logic of the plug-in 105 may determine ifany action needs to be taken in response to the API call and may alsodetermine whether or not to pass the API call along to the operatingsystem or other resource.

Moreover, in accordance with various embodiments, the state performancemonitoring plug-in 105 generates (block 202) state performance metricsbased on monitoring (e.g., intercepting) API calls by the application104 and/or system events being provided to the application 104. Each ofthe state performance metrics indicates a measurement of performance ofone of a plurality of operational states of the application 104 whileprocessed by the user terminal 100. An operational state of theapplication can correspond to the present operational state of theapplication when an API call is generated by the application 104 and/orwhen a system event is being provided to the application 104.

The plug-in 105 can generate (block 202) the state performance metricsbased on results of performing measurements of latency, wait time,processor bandwidth availability, memory space availability, networkcommunication bandwidth availability, and/or availability of variousdefined resources which the application 104 seeks to access inaccordance with various embodiments disclosed herein. Each of the stateperformance metrics indicates a measurement of performance of one of aplurality of operational states of the application 104 being processedby the user terminal 100.

For example, assume that the application 104 issues a system log APIcall to access a network server through a network interface of the userterminal 100 and the Internet. The plug-in 105 can intercept the APIcall and determine whether to allow the application 104 to access thenetwork interface. When allowed, the plug-in 105 can monitor how longthe application 104 has waited in an operational state without havingreceive a response from the network server, monitor a latency betweensending a request to the network server and receiving a response fromthe network server, and/or perform other measurements as describedherein. The plug-in 105 can generate a state performance metric based onthe measurement(s), and communicate the state performance metric to theapplication analysis computer 150 through the radio access network 160and the network 162.

The plug-in 105 can therefore include or programmatically invokeexecutable code that monitors and/or controls behavior of theapplication 104 by intercepting one or more API calls by the application104, executes monitoring and/or control code in response to the APIcall, and thereafter returns control to the application 104 and/orpasses the API call to the operating system or other resource forprocessing.

For example, in case the plug-in 105 is designed to limit access to afeature or resource on the user terminal 100 during a designate timeframe the plug-in 105 may intercept an API call from the application 104that invokes the feature and, if the API call is made outside thedesignated time frame, block access to the resource by preventing theAPI call from reaching the operating system or other resource instead ofpassing the API call to the operating system or other resource. APIcalls and other operations that can be performed by an application toobtain access to a resource of the user terminal 100 are more generallyreferred to as “requests” for convenience of reference. The plug-in 105can therefore “block” access by a request from the application 104 to aresource of the user terminal 100 by preventing the request (e.g., APIcall) from reaching the operating system or other resource.

With continuing reference to FIG. 2, although various embodiments aredescribed in the context of API calls, the embodiments may alternativelyor additionally be used to intercept and measure system events providedby an operating system to the application 104. The state performancemonitoring plug-in 105 observes or intercepts the API call, and mayforward the API call to the operating system for processing. Theoperating system may process API call by providing the API call to orreading data from a resource of the user terminal 100, and the resourcemay provide a response which is intercepted and forwarded through theplug-in 105 to the application 104. The plug-in 105 generates (block202) a state performance metric based on measurements of the wait time,response latency, and/or other operation measured for the API call isprocessed, and communicates the state performance metric to theapplication analysis computer 150. As explained above, the stateperformance metric indicates a measurement of performance of one of aplurality of operational states of the application 104 while processedby the user terminal 100.

The application analysis computer 150 receives (block 204) reports fromthe user terminals 100 a-100 n. The reports containing identifiers foroperational states of the application 104 being processed by the userterminals 100 a-100 n and contain state performance metrics. Each of thestate performance metrics indicates a measurement of performance for acorresponding identified one of the operational states of theapplication 104 being processed by one of the user terminals 100 a-100n. For each of the operational states of the application 104 identifiedin the reports, the application analysis computer 150 generates (block206) a rule, e.g., generates a new rule or updates an existing rule, foracceptable performance of the operational state of the application 104based on the state performance metrics of the operational state reportedby the user terminals 100 a-100 n. The computer 150 also stores in therepository 120 the rules associated with identifiers for correspondingones of the operational states of the application 104.

The application analysis computer 150 determines (block 208), e.g.,identifies, when one of the state performance metrics reported by one ofthe user terminals (e.g., 100 a) violates one of the rules in therepository for acceptable operational state performance for thecorresponding one of the operational states of the application 104. Inone embodiment, the application analysis computer 150 determines that astate performance metric reported by the user terminal 100 a violates arule when the state performance metric indicates that the application104 has waited a time duration that exceeds a maximum wait time definedby the rule without having received a response to the API call.

In one embodiment, the plug-in 105 generates (block 202) a stateperformance metric based on latency for a response to be provided to anAPI call by the application 104, and the application analysis computer150 determines (block 208) that the state performance metric exceeds adefined maximum latency allowed for a response to be provided to the APIcall by the application 104. In another embodiment, the plug-in 105generates (block 202) a state performance metric based on elapsed timewaiting without having received a response to an API call by theapplication 104, and the application analysis computer 150 determines(block 208) that the state performance metric exceeds a defined maximumwait time the application 104 is to wait to receive a response to theAPI call.

The application analysis computer 150 generates (block 210) a responsemessage that is communicated to the user terminal 100 responsive to thedetermination that the state performance metric violates the rule. Theuser terminal 100 receives the response message and controls (block 216)operation of the application 104 during the operational state responsiveto content of the response message.

In one embodiment, responsive to the rule being violated, theapplication analysis computer 150 generates (block 212) and communicatesto the user terminal 100 a contextual cue message containing informationidentifying a reason that the state performance metric reported by theuser terminal 100 violates the rule for acceptable operational stateperformance of the application 104. The plug-in 105 receives thecontextual cue message and displays (block 218) on a display device ofthe user terminal 100 a message generated based on content of thecontextual cue message.

FIG. 4 illustrates an example contextual cue message 218 that isdisplayed by the plug-in 105 on a display device of the user terminal100. The application analysis computer 150 determines based on violationof a rule that an operational state of an application login process istaking a threshold time longer than a typical observed login time, andfurther determines that the login delay is due to less than a thresholdamount of network bandwidth being available between the user terminal100 and a login authorization network node used by the application 104to authenticate login credentials of the user. The computer 150responsively generates a contextual cue message that is communicated tothe user terminal 100 for display on a display device. The examplecontextual cue 400 displayed in region 800 of a display device explainsto a user that the “login is taking longer than usual because of a slownetwork” and further explains that “75% of other users' logins take lesstime,” which better informs the user about the acceptability of thepresent login performance.

In another embodiment, responsive to the rule being violated, theapplication analysis computer 150 generates (block 214) and communicatesto the user terminal 100 a remedial action message. The plug-in 105 thencontrols (block 220) operation of the application responsive to theremedial action message.

In the further example of FIG. 4, an alternate contextual cue isdisplayed in region 402 by the plug-in 105, to explain to a user thatthe WIFI data connection is slow and a faster cellular data connectionis available. Moreover, the displayed message may contain a userselectable remedial action. The illustrated user selectable remedialaction is an offer to allow the user to select a soft button 404displayed on a touch sensitive interface to temporarily switch from aWIFI data connection to a cellular data connection for communicationwith a networked resource in order to speed up the applicationresponsiveness during the login process. The soft button 404 may bedisplayed responsive to the plug-in 105 receiving the correspondingremedial action message from the application analysis computer 150. Inthis manner, the plug-in 105 can display an explanation of theunderlying basis for a problem experienced by the application 104 and,moreover, can provide a temporary or permanent remedy to that problemfor selection by a user.

In one embodiment, the plug-in 105 is configured to temporarily switchfrom the WIFI data connection to the cellular data connection for use bythe application during only the operational state having the problemand, thereafter, constrained the application to using the WIFI dataconnection. Such temporary switching may be particularly advantageouswhen the user incurs cellular data roaming charges, such as whiletraveling in foreign countries. The user may thereby selectivelyconsider and allow such mode switching to allow expedited or furtheroperation of an application state the user decides has sufficient valueor importance to justify the consequential effect of allowing theswitching.

In another embodiment, the application analysis computer 150 determines,based on the state performance metric received from the user terminal100 violating a rule defined for the operational state, that the plug-in105 is likely the root cause of an operational problem with theapplication operational state because the plug-in 105 is blocking an APIcall from the application 104 to a resource of the user terminal 100that is necessary for operation of the operational state. The computer150 responsively generates (block 214) the remedial action message tocontain a command to disable interception by the plug-in 105 of the APIcall and/or other API calls from the application 104 during theoperational state identified by the identifier in the message from theuser terminal 100 containing the state performance metric. Responsive tothe command, the plug-in 105 disables or modifies (block 220) itsoperations to intercept the API call and/or other API calls from theapplication 104 during the one of the operational states identified bythe identifier received in the remedial action message.

In another embodiment, the application analysis computer 150 determines,based on the state performance metric received from the user terminal100 violating a rule defined for the operational state, that theapplication operational state is having a problem because a resource ofthe user terminal 100 is presently unavailable to be accessed by theapplication 104 via, for example, an API call. The computer 150 mayfurthermore determine based on the state performance metric whether theaccess is due to a user-defined permission preventing access to theresource by the application 104, due to the plug-in 105 blocking accessto the resource, due to the processor of the user terminal 100 havinginsufficient processing bandwidth to allow timely access to theresource, due to the network connection to the resource beingunavailable or having insufficient bandwidth, etc. The computer 150responsively communicates (block 214) to the plug-in 105 a responsemessage (e.g., a remedial action message) containing a defined valuethat the plug-in 105 is to provide to the application 104. The definedvalue imitates an acceptable response to the application 104 from theAPI call to the resource.

The plug-in 105 receives the response message and responsively provides(block 220) the defined value to the application 104 as the acceptableresponse from the API call to the resource. Thus, although during theoperational state the application 104 is unable to access a necessaryresource, the application analysis computer 150 operates in cooperationwith the plug-in 105 to provide a defined value to the application 104that appears to have come from the resource and which is known, based onthe rule, to be an acceptable response to the application 104. In oneembodiment, the defined value is determined and stored in the repository120 during generation of the rules, and may be updated over time basedon values that are observed to be provided by the subject resourceduring run-time operation of the wrapped application.

FIG. 5 illustrates another example contextual cue message 218 that isdisplayed on a display device of the user terminal 100. The applicationanalysis computer 150 determines (block 208) based on violation of arule that the application 104 is not responding to the user because theapplication 104 has been denied access to the user terminal's (phone's)present location, e.g., because no GPS data is available from a GPSresource and/or a user-defined permission has denied the application's104 requested access to a location service of the user terminal 100. Thecomputer 150 responsively generates (block 212) a contextual cue that iscommunicated to the user terminal 100 for display. The plug-in 105 onthe user terminal 100 displays a message 500 explaining the underlyingbasis for the application problem and displays a soft button 502 on atouch sensitive interface. The soft button 502, when selected by theuser, causes the plug-in 105 to provide default location data to theapplication 104 to imitate a response being provided from the locationservice that is presently unavailable to the application 104.

In this manner, the plug-in 105 can display an explanation of theunderlying basis for a problem experienced by the application 104 and,moreover, allows the user to remedy the problem by providing anacceptable response to the application on behalf of the unavailableresource to cause the application to continue processing without furtherdelay or error. In one embodiment, the default location data isdetermined and stored in the repository 120 during generation of therules. In another embodiment, the default location data is determined bythe user terminal 100 and/or by the application analysis computer 150based on one or more default location data responses from the GPSresource to one or more access requests by the application 104 or moregenerally by the user terminal 100.

Various embodiments have been described in the context of theapplication analysis computer 150 identifying (block 208) that a stateperformance metric violates a rule and responsively generating (block216) the response message. However, in some other embodiments the userterminal 100 performs operations to identify that a state performancemetric violates a rule and operations to generate a response messagethat controls operation of the plug-in 105 in the application 104, andwhich may be performed in addition to or as an alternative to theseoperations being performed by the application analysis computer 150.

FIG. 3 is a combined data flow diagram and flowchart of operations bythe user terminal 100 for generating rules for acceptable stateperformance metrics from the plug-in 105 and providing contextualinsights and/or controlling operation based on the rules, in accordancewith some embodiments of the present disclosure. Some of the operationsshown in FIG. 3 may be performed as described above regarding the blocksshown in FIG. 2 having the same reference numbers. The description ofblocks having the same reference numbers as FIG. 2 is not repeated herefor sake of brevity.

Referring to FIG. 3, the application analysis computer 150 sends (block300) rules for acceptable state performance metrics to the user terminal100. The plug-in 105 receives the rules for acceptable state performancemetrics and adds (block 302) the rules to a local repository within theuser terminal 100. The application 104 can perform (block 200) API callsto resources of the user terminal 100 and the plug-in 105 can interceptor otherwise observe the API calls, and generate (block 202) stateperformance metrics based on measurements perform relative to the APIcalls. The plug-in 105 can similarly intercept system events provided bythe operating system to the application 104, and generate (block 202)state performance metrics based on measurements perform relative to thesystem events. The plug-in 105 identifies (block 304) a stateperformance metric that violates one of the rules for acceptable stateperformance. The plug-in 105 responsively generates (block 306) aresponse message, which may include generating (block 212) a contextualcue message and/or generating (block 214) a remedial action message toremedy problematic operation of an application state.

The plug-in 105 controls (block 216) its operation and can furthercontrol operation of the application 104 by displaying (block 218) acontextual cue on display device and/or by disabling or modify (block220) operation of the plug-in 105 and/or disabling or modifying anapplication state to remedy the state having the problematic stateperformance metric. The control operation can include providing adefault resource response to the application 104 when the resource isnot presently available to be accessed by the application 104.

FIG. 6 is a flowchart of further operations that can be performed by theuser terminal 100 to remedy a problematic operational state of anapplication due to unavailability of a resource in accordance with someembodiments of the present disclosure. Referring to FIG. 6, a remedialaction message is received (block 600) which causes disabling ormodification (block 220) of operation of a feature of the plug-in 105and/or an operational state of the application 104 associated with theproblematic state performance metric. One or more of the illustratedoperations can be performed to carry out the disabling or modification(block 220).

In one embodiment, the plug-in 105 receives a remedial action messagecontaining a command and the identifier for the one of the operationalstates, where the command indicates that a resource that the application104 is attempting to access is unavailable to the application 104.Responsive to the command, the plug-in 105 controls (block 602)operation of the application 104 to disable the application 104 fromseeking access to the resource during the one of the operational statesidentified by the identifier received in the remedial action message.

For example, developers typically code an application program to operatebased on the assumption that if during setup of the application a set ofpermissions is granted (e.g., based on user defined preferences orselections) for the application to access corresponding resources ofuser devices, then the application will have access to those resourceswhenever requested by the application. However, the application 104 canbe controlled by the plug-in 105 written by an entirely differententity, and the plug-in 105 can exert unexpected control over thoseaccess requests. The plug-in 105 can block a request from a feature ofthe application 104 to access a particular resource when an accesscontrol rule used by the plug-in 105 is satisfied. Such blocking ofresource access can trigger unexpected operational behavior from theapplication 104 and result in erroneous operation during the accessoperational state. The erroneous operation can include ceasing furtheroperations while hanging in an infinite loop or wait state whileawaiting a requested response from the resource. Another erroneousoperation can include terminating operation due to a mathematical errorfrom processing a register value or memory value that is erroneouslyinterpreted as a valid response from the requested resource. Stillanother erroneous operation can include causing a change in aconditional branch (e.g., the blocked access erroneously affects thebranch condition) during processing of operations of the applicationprogram due to absence of a response from the requested resource. One ormore of these problems can be overcome by the plug-in 105 controlling(block 602) operation of the application 104 to disable the application104 from seeking access to the resource during the one of theoperational states identified by the identifier received in the remedialaction message, when the remedial action message indicates that theresource is presently unavailable to the application 104.

In another embodiment, the plug-in 105 responds to the remedial actionmessage by providing (block 604) an acceptable response to theapplication 104 when, during the operational state, the application 104is attempting to access a necessary but unavailable resource of the userdevice 100. As explained above, the resource may be unavailable due to,for example, access to the resource being blocked by a user definedpermission setting, unavailability or insufficient availability ofnetwork communications between the user terminal 100 and a network nodehosting the resource, conflicting use of the resource by anotherapplication processed by the user terminal 100, etc.

In another embodiment, the plug-in 105 generates (block 606) defaultlocation data as a response to an application call to a GPS resourcewhile access to the GPS resource is blocked or otherwise unavailable.For example, a restaurant locator application assumes that the device'slocation from a GPS resource is available all of the time or, if it isturned-off, the application 104 is notified of that status andconfigured to then prompt the user to turn-on the GPS resource. Howeverthe plug-in 105 can dynamically control whether the application 104 isallowed access to the GPS resource or the application 104 may not beprogrammed to properly handle occurrence of other conditions that canprevent necessary access to the GPS resource. When a request from theapplication 104 to the GPS resource is blocked by the plug-in 105 orthat a GPS resource is otherwise unavailable, the application 104 canexhibit erroneous operation. In accordance with this embodiment, theplug-in 105 provides (block 604) the default location data as a responseto an application call to a GPS resource while access to the GPSresource is blocked or otherwise unavailable. The default location maybe defined by a user (e.g., such as a work address that the user doesn'tmind sharing) or may be based on a previous location that was recordedwhile access to the GPS resource was available, such as a locationreported by the GPS resource responsive to a previous request from theapplication 104.

In another embodiment, the plug-in 105 generates (block 608) defaultpicture data and/or video stream data as a response to the application104 API call to a camera resource while access to the camera resource isblocked or otherwise unavailable. Thus, for example, a photo capture orediting application may always expect that the user terminal's cameraresource to be available for its operations. However the plug-in 105 candynamically control whether the application 104 is allowed access to thecamera resource and/or the camera resource may be unavailable for otherreasons. When a request from the application 104 to the camera resourceis blocked or otherwise unavailable, the application 104 can exhibiterroneous operation (e.g., triggering an operating system of the userdevice 100 to force shutdown due to erroneous application operation). Inaccordance with this embodiment, the plug-in 105 provides (block 608)the default picture data and/or video stream data as a response to theapplication 104 while access to the camera resource is blocked orotherwise unavailable. The default picture data and/or video data streammay be defined by the user and/or may be based on previous picture dataand/or video data stream that was recorded while access to the cameraresource was available, such as picture data and/or video data streamreceived from the camera resource responsive to a previous request fromthe application 104.

In another embodiment, the plug-in 105 generates (block 610) a defaultHTTP response object as a response to an application Internet requestthrough a network resource while access to the network resource isblocked or otherwise unavailable. In another embodiment, the plug-in 105generates (block 612) a default contact information data structure as aresponse to a request from the application 104 to access a repository ofcontact information while such access is blocked or otherwiseunavailable.

Accordingly, one or more of the operations of block 220 can be performedto configure the plug-in 105 to provide an acceptable response to theapplication 104 on behalf of the resource that is presently unavailableto the application 104. The default response or other generated responseto the application 104 can enable the application 104 to continueprocessing through the present application state or subsequentapplication states without further problem.

FIG. 7 is a block diagram of a user terminal 100 configured according tosome embodiments of the present disclosure. Referring to FIG. 1, themobile terminal 100 includes a processor 700, a memory 710 and a networkinterface which may include a radio access transceiver 720 and/or awired network interface 722 (e.g., Ethernet interface). The radio accesstransceiver 720 can include, but is not limited to, a LTE or othercellular transceiver, WLAN transceiver (IEEE 802.11), WiMax transceiver,or other radio communication transceiver configured to communicate withthe application analysis computer 150 via a radio access network.

The processor 700 may include one or more data processing circuits, suchas a general purpose and/or special purpose processor, such as amicroprocessor and/or digital signal processor. The processor 700 isconfigured to execute computer program code in the memory 710, describedbelow as a non-transitory computer readable medium, to perform at leastsome of the operations described herein as being performed by a userterminal. The computer program code may include an operating system 712,and an application program 104 that includes a state performancemonitoring plug-in 105. In some further embodiments, the computerprogram code includes a rule repository 716 and rule analysis code 714.The plug-in 105 generates state performance metrics based onmeasurements performed during operational states of the application 104.The rule repository 716 can include, for each of the operational statesof the application 104, a rule for acceptable performance of theoperational state of the application 104 relative to a state performancemetric. The rule analysis code 714 can determine when one of the stateperformance metrics that is generated by the plug-in 105 violates one ofthe rules in the repository 716 for acceptable operational stateperformance for the corresponding one of the operational states of theapplication 104. The user terminal 100 may further include a speaker730, user input interface 732 (e.g., touch screen, keyboard, keypad,etc.), a display device 734, and a microphone 736.

As used herein, the term “user terminal” may include, withoutlimitation, a satellite or cellular radiotelephone; a PDA or smart phonethat can include a radiotelephone, pager, Internet/intranet access, Webbrowser, organizer, calendar and/or a global positioning system (GPS)receiver; and a tablet computer, laptop computer, desktop computer thatincludes a network interface allowing communication with an applicationanalysis computer via a data network (e.g., private network and/or apublic network such as the Internet).

FIG. 8 is a block diagram of an application analysis computer 150configured according to some embodiments of the present disclosure. Theapplication analysis computer 150 includes a processor 800, a memory810, and a network interface which may include a radio accesstransceiver 826 and/or a wired network interface 824 (e.g., Ethernetinterface). The radio access transceiver 826 can include, but is notlimited to, a LTE or other cellular transceiver, WLAN transceiver (IEEE802.11), WiMax transceiver, or other radio communication transceiverconfigured to communicate with the user terminal 100 via a radio accessnetwork.

The processor 800 may include one or more data processing circuits, suchas a general purpose and/or special purpose processor (e.g.,microprocessor and/or digital signal processor) that may be collocatedor distributed across one or more networks. The processor 800 isconfigured to execute computer program code in the memory 810, describedbelow as a non-transitory computer readable medium, to perform at leastsome of the operations described herein as being performed by anapplication analysis computer. The computer program code may includeapplication analysis code 812 configured to receive and process stateperformance metrics in accordance with one or more embodiments herein.The application analysis computer 150 may further include a user inputinterface 820 (e.g., touch screen, keyboard, keypad, etc.) and a displaydevice 822.

Further Definitions and Embodiments

In the above-description of various embodiments of the presentdisclosure, aspects of the present disclosure may be illustrated anddescribed herein in any of a number of patentable classes or contextsincluding any new and useful process, machine, manufacture, orcomposition of matter, or any new and useful improvement thereof.Accordingly, aspects of the present disclosure may be implemented inentirely hardware, entirely software (including firmware, residentsoftware, micro-code, etc.) or combining software and hardwareimplementation that may all generally be referred to herein as a“circuit,” “module,” “component,” or “system.” Furthermore, aspects ofthe present disclosure may take the form of a computer program productcomprising one or more computer readable media having computer readableprogram code embodied thereon.

Any combination of one or more computer readable media may be used. Thecomputer readable media may be a computer readable signal medium or acomputer readable storage medium. A computer readable storage medium maybe, for example, but not limited to, an electronic, magnetic, optical,electromagnetic, or semiconductor system, apparatus, or device, or anysuitable combination of the foregoing. More specific examples (anon-exhaustive list) of the computer readable storage medium wouldinclude the following: a portable computer diskette, a hard disk, arandom access memory (RAM), a read-only memory (ROM), an erasableprogrammable read-only memory (EPROM or Flash memory), an appropriateoptical fiber with a repeater, a portable compact disc read-only memory(CD-ROM), an optical storage device, a magnetic storage device, or anysuitable combination of the foregoing. In the context of this document,a computer readable storage medium may be any tangible medium that cancontain, or store a program for use by or in connection with aninstruction execution system, apparatus, or device.

A computer readable signal medium may include a propagated data signalwith computer readable program code embodied therein, for example, inbaseband or as part of a carrier wave. Such a propagated signal may takeany of a variety of forms, including, but not limited to,electro-magnetic, optical, or any suitable combination thereof. Acomputer readable signal medium may be any computer readable medium thatis not a computer readable storage medium and that can communicate,propagate, or transport a program for use by or in connection with aninstruction execution system, apparatus, or device. Program codeembodied on a computer readable signal medium may be transmitted usingany appropriate medium, including but not limited to wireless, wireline,optical fiber cable, RF, etc., or any suitable combination of theforegoing.

Computer program code for carrying out operations for aspects of thepresent disclosure may be written in any combination of one or moreprogramming languages, including an object oriented programming languagesuch as Java, Scala, Smalltalk, Eiffel, JADE, Emerald, C++, C#, VB.NET,Python or the like, conventional procedural programming languages, suchas the “C” programming language, Visual Basic, Fortran 2003, Perl, COBOL2002, PHP, ABAP, dynamic programming languages such as Python, Ruby andGroovy, or other programming languages. The program code may executeentirely on the user's computer, partly on the user's computer, as astand-alone software package, partly on the user's computer and partlyon a remote computer or entirely on the remote computer or server. Inthe latter scenario, the remote computer may be connected to the user'scomputer through any type of network, including a local area network(LAN) or a wide area network (WAN), or the connection may be made to anexternal computer (for example, through the Internet using an InternetService Provider) or in a cloud computing environment or offered as aservice such as a Software as a Service (SaaS).

Aspects of the present disclosure are described herein with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems), and computer program products according to embodiments of thedisclosure. It will be understood that each block of the flowchartillustrations and/or block diagrams, and combinations of blocks in theflowchart illustrations and/or block diagrams, can be implemented bycomputer program instructions. These computer program instructions maybe provided to a processor of a general purpose computer, specialpurpose computer, or other programmable data processing apparatus toproduce a machine, such that the instructions, which execute via theprocessor of the computer or other programmable instruction executionapparatus, create a mechanism for implementing the functions/actsspecified in the flowchart and/or block diagram block or blocks.

These computer program instructions may also be stored in a computerreadable medium that when executed can direct a computer, otherprogrammable data processing apparatus, or other devices to function ina particular manner, such that the instructions when stored in thecomputer readable medium produce an article of manufacture includinginstructions which when executed, cause a computer to implement thefunction/act specified in the flowchart and/or block diagram block orblocks. The computer program instructions may also be loaded onto acomputer, other programmable instruction execution apparatus, or otherdevices to cause a series of operational steps to be performed on thecomputer, other programmable apparatuses or other devices to produce acomputer implemented process such that the instructions which execute onthe computer or other programmable apparatus provide processes forimplementing the functions/acts specified in the flowchart and/or blockdiagram block or blocks.

It is to be understood that the terminology used herein is for thepurpose of describing particular embodiments only and is not intended tobe limiting of the invention. Unless otherwise defined, all terms(including technical and scientific terms) used herein have the samemeaning as commonly understood by one of ordinary skill in the art towhich this disclosure belongs. It will be further understood that terms,such as those defined in commonly used dictionaries, should beinterpreted as having a meaning that is consistent with their meaning inthe context of this specification and the relevant art and will not beinterpreted in an idealized or overly formal sense unless expressly sodefined herein.

The flowchart and block diagrams in the figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods, and computer program products according to variousaspects of the present disclosure. In this regard, each block in theflowchart or block diagrams may represent a module, segment, or portionof code, which comprises one or more executable instructions forimplementing the specified logical function(s). It should also be notedthat, in some alternative implementations, the functions noted in theblock may occur out of the order noted in the figures. For example, twoblocks shown in succession may, in fact, be executed substantiallyconcurrently, or the blocks may sometimes be executed in the reverseorder, depending upon the functionality involved. It will also be notedthat each block of the block diagrams and/or flowchart illustration, andcombinations of blocks in the block diagrams and/or flowchartillustration, can be implemented by special purpose hardware-basedsystems that perform the specified functions or acts, or combinations ofspecial purpose hardware and computer instructions.

The terminology used herein is for the purpose of describing particularaspects only and is not intended to be limiting of the disclosure. Asused herein, the singular forms “a”, “an” and “the” are intended toinclude the plural forms as well, unless the context clearly indicatesotherwise. It will be further understood that the terms “comprises”and/or “comprising,” when used in this specification, specify thepresence of stated features, integers, steps, operations, elements,and/or components, but do not preclude the presence or addition of oneor more other features, integers, steps, operations, elements,components, and/or groups thereof. As used herein, the term “and/or”includes any and all combinations of one or more of the associatedlisted items. Like reference numbers signify like elements throughoutthe description of the figures.

The corresponding structures, materials, acts, and equivalents of anymeans or step plus function elements in the claims below are intended toinclude any disclosed structure, material, or act for performing thefunction in combination with other claimed elements as specificallyclaimed. The description of the present disclosure has been presentedfor purposes of illustration and description, but is not intended to beexhaustive or limited to the disclosure in the form disclosed. Manymodifications and variations will be apparent to those of ordinary skillin the art without departing from the scope and spirit of thedisclosure. The aspects of the disclosure herein were chosen anddescribed in order to best explain the principles of the disclosure andthe practical application, and to enable others of ordinary skill in theart to understand the disclosure with various modifications as aresuited to the particular use contemplated.

1. A method, comprising: performing operations as follows on a processorof an application analysis computer: receiving reports from userterminals containing identifiers for operational states of anapplication being processed by the user terminals and containing stateperformance metrics, each of the state performance metrics indicating ameasurement of performance for a corresponding identified one of theoperational states of the application being processed by one of the userterminals; for each of the operational states of the applicationidentified in the reports, generating a rule for acceptable performanceof the operational state of the application based on the stateperformance metrics of the operational state reported by the userterminals; and storing in a repository the rules associated withidentifiers for corresponding ones of the operational states of theapplication.
 2. The method of claim 1, further comprising: determiningwhen one of the state performance metrics reported by one of the userterminals violates one of the rules in the repository for acceptableoperational state performance for the corresponding one of theoperational states of the application; and communicating a responsemessage to the one of the user terminals responsive to the determinationthat the one of the state performance metrics violates one of the rulesin the repository.
 3. The method of claim 2, wherein the, for each ofthe operational states of the application identified in the reports,generating a rule for acceptable performance of the operational state ofthe application based on the state performance metrics of theoperational state reported by the user terminals, comprises:mathematically combining the performance metrics for the operationalstate to generate a threshold value representing a boundary limit foracceptable performance of the operational state.
 4. The method of claim3, wherein: the threshold value represents a maximum wait time theapplication is to wait to receive a response to an applicationprogramming interface call by the application; and the determining whenone of the state performance metrics reported by one of the userterminals violates one of the rules in the repository for acceptableoperational state performance for the corresponding one of theoperational states of the application, comprises: determining when theone of the state performance metrics reported by the one of the userterminals exceeds the maximum wait time.
 5. The method of claim 2,wherein: the determining when one of the state performance metricsreported by one of the user terminals violates one of the rules in therepository for acceptable operational state performance for thecorresponding one of the operational states of the application,comprises: retrieving the rule from the repository using the identifiercontained in the one of the reports corresponding to the one of thestate performance metrics in one of the reports.
 6. The method of claim1, wherein the communicating a response message to the one of the userterminals responsive to the determination that the one of the stateperformance metrics violates one of the rules in the repository,comprises: communicating to the one of the user terminals a contextualcue message containing information identifying a reason that the one ofthe state performance metrics reported by the one of the user terminalsviolates the rule for acceptable operational state performance of theapplication.
 7. The method of claim 1, wherein the communicating aresponse message to the one of the user terminals responsive to thedetermination that the one of the state performance metrics violates oneof the rules in the repository, comprises: communicating to the one ofthe user terminals a remedial action message containing a defined valuefor the application to use as an acceptable response to an applicationprogramming interface (API) call to a resource of the one of the userterminal when the resource is not available to provide a response to theAPI call.
 8. The method of claim 1, further comprising: communicatingthe rules from the repository with identifiers for corresponding ones ofthe operational states of the application to the user terminals fortheir local determination of when one of the state performance metricsdetermined by one of the user terminals violates one of the rules foracceptable operational state performance for the corresponding one ofthe operational states of the application.
 9. A method, comprising:performing operations as follows on a processor of a user terminal:generating state performance metrics, each of the state performancemetrics indicating a measurement of performance of one of a plurality ofoperational states of an application processed by the user terminal;communicating the state performance metrics to an application analysiscomputer via a data network; determining an action responsive to one ofthe state performance metrics for one of the operational states beingdetermined to violate a rule for acceptable operational stateperformance of the application; and controlling operation of theapplication during the one of the operational states responsive to theaction.
 10. The method of claim 9, wherein the determining an actionresponsive to one of the state performance metrics for one of theoperational states being determined to violate a rule for acceptableoperational state performance of the application, comprises: receiving aresponse message from the application analysis computer responsive tothe one of the state performance metrics for the one of the operationalstates being determined by the application analysis computer to violatethe rule for acceptable operational state performance of theapplication; and determining the action based on content of the responsemessage.
 11. The method of claim 10, wherein the controlling operationof the application during the one of the operational states responsiveto the action, comprises: generating a contextual cue message based oncontent of the response message, the contextual cue message identifyinga reason that the one of the state performance metrics reported by oneof the user terminals violates the rule for acceptable operational stateperformance of the application displaying the contextual cue messagethrough a display device of the user terminal.
 12. The method of claim10, wherein: the communicating the state performance metrics to theapplication analysis computer via a data network, comprises:communicating messages to the application analysis computer, each of themessages containing an identifier for one of the operational states ofthe application and a state performance metric for the one of theoperational states; the receiving a response message from theapplication analysis computer, comprises: receiving a remedial actionmessage containing a command and the identifier for the one of theoperational states, wherein the command indicates that a resource thatthe application is attempting to access is unavailable to theapplication; and the controlling operation of the application during theone of the operational states responsive to the action, comprises:responsive to the command, controlling the application to disable theapplication from seeking access to the resource during the one of theoperational states identified by the identifier received in the remedialaction message.
 13. The method of claim 10, wherein: the receiving aresponse message responsive to one of the state performance metrics forone of the operational states being determined to violate a rule foracceptable operational state performance of the application, comprises:determining a defined value based on the response message; and thecontrolling operation of the application during the one of theoperational states responsive to the action, comprises: responsive tothe remedial action message, providing the defined value to theapplication to use as an acceptable response to an applicationprogramming interface (API) call to a resource of the user terminal whenthe resource is not available to provide a response to the API call. 14.The method of claim 13, wherein the providing the defined value to theapplication to use as an acceptable response to an applicationprogramming interface (API) call to a resource of the user terminal whenthe resource is not available to provide a response to the API call,comprises: determining a default location based on the response message;and providing the default location as a response to the API call to aGPS resource of the user terminal absent having received a presentlocation from the GPS resource.
 15. The method of claim 13, wherein theproviding the defined value to the application to use as an acceptableresponse to an application programming interface (API) call to aresource of the user terminal when the resource is not available toprovide a response to the API call, comprises: determining a defaultHTTP response object based on the response message; and providing thedefault HTTP response object as a response from a network node viaInternet to the API call by the application absent having received aHTTP response object from the network node.
 16. The method of claim 13,wherein the providing the defined value to the application to use as anacceptable response to an application programming interface (API) callto a resource of the user terminal when the resource is not available toprovide a response to the API call, comprises: determining defaultcamera data based on the response message; and providing the defaultcamera data as a response from a camera of the user terminal to the APIcall by the application absent having received camera data from thecamera.
 17. The method of claim 9, wherein the determining an actionresponsive to one of the state performance metrics for one of theoperational states being determined to violate a rule for acceptableoperational state performance of the application, comprises: selectingthe rule for acceptable operational state performance of the applicationfrom among a plurality of rules contained in a repository based on theone of a plurality of operational states for which the one of the stateperformance metrics was generated; comparing the one of the stateperformance metrics to the rule that was selected to determine that theone of the state performance metrics violates the rule for acceptableoperational state performance of the application; determining the actionbased on the rule that is determined to be violated.
 18. The method ofclaim 17, wherein: the generating state performance metrics, each of thestate performance metrics indicating a measurement of performance of oneof a plurality of operational states of an application processed by theuser terminal, comprises: generating the state performance metrics basedon latency for a response to be provided to an application programminginterface call by the application; the comparing the one of the stateperformance metrics to the rule that was selected to determine that theone of the state performance metrics violates the rule for acceptableoperational state performance of the application, comprises: determiningthat the one of the state performance metrics exceeds a defined maximumlatency allowed for a response to be provided to the applicationprogramming interface call by the application.
 19. The method of claim17, wherein: the generating state performance metrics, each of the stateperformance metrics indicating a measurement of performance of one of aplurality of operational states of an application processed by the userterminal, comprises: generating the state performance metrics based onelapsed time waiting without having received a response to anapplication programming interface call by the application; the comparingthe one of the state performance metrics to the rule that was selectedto determine that the one of the state performance metrics violates therule for acceptable operational state performance of the application,comprises: determining that the one of the state performance metricsexceeds a defined maximum wait time the application is to wait toreceive a response to the application programming interface call. 20.The method of claim 9, wherein: the determining an action responsive toone of the state performance metrics for one of the operational statesbeing determined to violate a rule for acceptable operational stateperformance of the application, comprises: determining a defined value;the controlling operation of the application during the one of theoperational states responsive to the action, comprises: providing thedefined value to the application to use as an acceptable response to anapplication programming interface (API) call to a resource of the userterminal when the resource is not available to provide a response to theAPI call.